package com.soft.javase.ch05.inner;

/**
 * @author wangzhisen
 * @Desc TODO
 * @date 2025/4/23
 * 类中有哪些成员？成员属性、成员方法、构造方法、代码块、内部类
 *
 *
 * 内部类
 * 1.在外部类中，声明一个class类，就将其称为内部类
 * 2.语法  public [abstract] [final] [static] class InnerClass{}
 * 3.分类
 *  3.1 成员内部类
 *      1）、站在外部类的角度来看：跟成员属性、成员方法是一样的存在
 *      2）、站在内部类的角度来看：跟外部类一样；可以在内部类中正常使用外部类的成员
 *      3）、站在使用的角度来看：
 *              在外部类中直接使用，内部类的类型  对象名 = 外部类的对象.new 内部类的构造方法();
 *              在其他类中直接使用，外部类类名.内部类的类型  对象名 = 外部类的对象.new 内部类的构造方法();
 *
 *  3.2 局部内部类
 *      1）、在声明方法时，在方法的内部声明内部类，称为局部内部类
 *      2）、随着方法的调用，创建局部内部类的对象进行使用
 *
 *  3.3 静态内部类
 *      1）、public static class InnerClass{}
 *      2）、站在外部类的角度来看：跟静态属性、静态方法是一样的存在
 *      3）、站在使用的角度来看：
 *               在外部类中直接使用，内部类的类型 对象名 = new 内部类的构造方法();
 *               在其他类中直接使用，外部类类名.内部类的类型  对象名 = new 外部类类名.内部类的构造方法();
 *
 *  3.4 匿名内部类
 *      1）、简化代码
 *      new 抽象类(){ @Override  }、new 接口(){ @Override  }
 *      2)、不需要再编写实现类去继承抽象类，实现其抽象方法；
 *      不需要再编写实现类去实现接口，实现其抽象方法；
 *      3）、搭配Lambda表达式进行使用简化
 */

//外部类
class OuterClass1{

    //成员属性
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    //成员方法
    public void eat(){
        System.out.println(name+"正在吃饭...");
    }

    //成员内部类
    class InnerClass{
        private int age;

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        public void sleep(){
            //调用外部类的成员方法
            eat();
            //外部类的成员属性
            System.out.println("一个"+age+"岁，名字叫"+name+"的，正在睡觉");
        }
    }

    public static void main(String[] args) {
        OuterClass1 outerClass1 = new OuterClass1();
        outerClass1.name="张三";
        outerClass1.eat();

        //使用成员内部类  外部类对象.new 内部类的构造方法()
        InnerClass innerClass = outerClass1.new InnerClass();
        innerClass.age=15;
        innerClass.sleep();
    }
}
public class InnerDemo1 {
}
